<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>C++ Tutorial: Quiz - Recursion</title>
  <meta
 content="C++ Tutorial: Quiz - Recursion"
 name="description" />
  <meta
 content="C++ Tutorial, Quiz - Recursion, String Permutations, Fibonacci Sequence, Subsets of a Set, Interview Questions"
 name="keywords" />
  <meta http-equiv="Content-Type"
 content="text/html; charset=ISO-8859-1" />
  <link type="text/css" rel="stylesheet" href="../images/bogostyleWidePre.css" />
</head>
<body>
<div id="page" align="center">
<div id="content" style="width: 800px;">
<div id="logo">
<div class="whitetitle" style="margin-top: 70px;">bogotobogo </div>
</div>
<div id="topheader">
<div class="headerbodytext" align="left"><br />
<strong>Bogotobogo</strong><br />
contact@bogotobogo.com </div>
<div class="smallgraytext" id="toplinks"><a href="../index.html">Home</a>
| <a href="../sitemap.html">Sitemap</a>
| <a href="../blog" target="_blank">Contact Us</a>
</div>
</div>
<div id="menu">
<div class="smallwhitetext" style="padding: 9px;" align="right"><a
 href="../index.html">Home</a>
| <a href="../about_us.html">About Us</a>
| <a href="../products.html">Products</a>
| <a href="../our_services.html">Our Services</a>
| <a href="../blog" target="_blank">Contact Us</a>
</div>
</div>
<div id="submenu">
<div class="smallgraytext" style="padding: 9px;" align="right">
<a href="../gif.html">Gif</a> 
|<a href="../java_applet.html">JavaApplet/Web Start</a>
| <a href="../flash.html">Flash</a>
| <a href="../shockwave.html">ShockWave</a>
| <a href="../svg.html">SVG</a>
| <a href="../iPhone.html">iPhone/iPad</a>
| <a href="../android.html">Android</a>
| <a href="../OnHTML5.html">HTML5</a>
| <a href="../Algorithms/algorithms.html">Algorithms</a>
| <a href="../News/NewsMain.html">News</a>
| <a href="../cplusplus/cpptut.html">C++</a>
| <a href="../Java/tutorial/on_java.html">Java</a>
| <a href="../php/phptut.html">PHP</a>
| <a href="../DesignPatterns/introduction.html">Design Patterns</a>
| <a href="../python/pytut.html">Python</a> 
| <a href="../CSharp/.netframework.html">C#</a>
| <a href="../forums.html">Forums</a> 
| <a href="../VisualBasicSQL/introduction.html">Visual Basic</a>
</div>
</div>


<div id="contenttext">
<br />
<br />
<!-- Use of this code assumes agreement with the Google Custom Search Terms of Service. -->
<!-- The terms of service are available at http://www.google.com/cse/docs/tos.html -->
<form name="cse" id="searchbox_demo" action="http://www.google.com/cse">
  <input type="hidden" name="cref" value="" />
  <input type="hidden" name="ie" value="utf-8" />
  <input type="hidden" name="hl" value="" />
  <input name="q" type="text" size="40" />
  <input type="submit" name="sa" value="Search" />
</form>
<script type="text/javascript" src="http://www.google.com/cse/tools/onthefly?form=searchbox_demo&lang="></script>


<div id="bookmarkshare">
<script type="text/javascript">var addthis_config = {"data_track_clickback":true};</script>
<a class="addthis_button" href="http://www.addthis.com/bookmark.php?v=250&amp;username=khhong7"><img src="http://s7.addthis.com/static/btn/v2/lg-share-en.gif" width="125" height="16" alt="Bookmark and Share" style="border:0"/></a><script type="text/javascript" src="http://s7.addthis.com/js/250/addthis_widget.js#username=khhong7"></script>
</div>


<br />
<br />
<br />
<br />
<div style="padding: 10px;"><span class="titletext">C++ Tutorial <br />
Quiz - Recursion</span></div>

<img src="../images/cplusplus/cpp_logo.jpg" alt="cplusplus logo"/>

<br />
<br />
<div class="bodytext" style="padding: 12px;" align="justify"> 
<div class="subtitle_2nd" id="SubList">List of C++ Tutorials</div>
<ul>
   <li><a href="cpptut.html">C++ Home</a> </li>
   <li><a href="string.html">String</a> </li>
   <li><a href="constructor.html">Constructor</a> </li>
   <li><a href="operatoroverloading.html">Operator Overloading</a></li> 
   <li><a href="virtualfunctions.html">Virtual Functions</a></li>
   <li><a href="dynamic_cast.html">Dynamic Cast Operator</a></li>
   <li><a href="typecast.html">Type Cast Operators</a></li>
   <li><a href="autoptr.html">Class auto_ptr</a></li>
   <li><a href="templates.html">Templates</a></li>
   <li><a href="references.html">References for Built-in Types</a></li>
   <li><a href="valuevsreference.html">Pass by Value vs. Pass by Reference</a></li>
   <li><a href="memoryallocation.html">Memory Allocation</a></li>
   <li><a href="friendclass.html">Friend Functions and Friend Classes</a></li>
   <li><a href="functors.html">Functors (Function Objects)</a></li>
   <li><a href="statics.html">Static Variables and Static Class Members</a></li>
   <li><a href="exceptions.html">Exceptions</a></li>
   <li><a href="pointers.html">Pointers</a></li>
   <li><a href="pointers2.html">Pointers II - void*, Pointer/Array, and Pointer to Pointer</a></li>
   <li><a href="pointers3.html">Pointers III - Pointer to Function, Null Pointer</a></li>
   <li><a href="assembly.html">Taste of Assembly</a></li>
   <li><a href="smallprograms.html">Small Programs</a></li>
   <li><a href="linkedlist.html">Linked List Examples</a></li>
   <li><a href="binarytree.html">Binary Tree Example Code</a></li>
   <li><a href="stl.html">Standard Template Library (STL)</a></li>
   <li><a href="stl2.html">Standard Template Library (STL) II - Maps</a></li>
   <li><a href="stl3_iterators.html">Standard Template Library (STL) III - Iterators</a></li>
   <li><a href="slicing.html">Object Slicing and Virtual Table</a></li>
   <li><a href="this_pointer.html">The this Pointer</a></li>
   <li><a href="stackunwinding.html">Stack Unwinding</a></li>
   <li><a href="upcasting_downcasting.html">Upcasting and Downcasting</a></li>
   <li><a href="object_returning.html">Object Returning</a></li>
   <li><a href="private_inheritance.html">Private Inheritance</a></li>
   <li><a href="cplusplus_keywords.html">C++_Keywords</a></li>
   <li><a href="multithreaded.html">Multi-Threaded Programming - Terminology</a></li>
   <li><a href="multithreaded2A.html">Multi-Threaded Programming II - Native Thread for Win32 (A) </a></li>
   <li><a href="multithreaded2B.html">Multi-Threaded Programming II -  Native Thread for Win32 (B) </a></li>
   <li><a href="multithreaded2C.html">Multi-Threaded Programming II -  Native Thread for Win32 (C) </a></li>
   <li><a href="multithreaded2.html">Multi-Threaded Programming II - C++ Thread for Win32</a></li>
   <li><a href="multithreaded3.html">Multi-Threaded Programming III - C++ Class Thread for Pthreads</a></li>
   <li><a href="multithreadedDebugging.html">Multithread Debugging</a></li>
   <li><a href="embeddedSystemsProgramming.html">Embedded Systems Programming</a></li>
   <li><a href="boost.html">Boost</a></li>
   <li>Programming Questions and Solutions
    <ul>
       <li><a href="quiz_strings_arrays.html">Strings and Arrays</a></li>
       <li><a href="quiz_linkedlist.html">Linked List</a></li>
       <li><a href="quiz_recursion.html">Recursion</a></li>
       <li><a href="quiz_bit_manipulation.html">Bit Manipulation</a> </li>
       <li><a href="google_interview_questions.html">140 Google Interview Questions</a> </li>
    </ul>
   </li>

</ul>
</div>
<br />

<br />
<img src="images/quiz/HongCheonKang.png" alt="HongCheonKang"/>
<br />
<br />
<br />

<div class="bodytext" style="padding: 12px;" align="justify"> 
<div class="subtitle_2nd" id="SubList">List of codes using recursion</div>
<ul>
   <li> <a href="#printing">Printing a String Reversed</a> </li>
   <li> <a href="#factorial">Factorial</a> </li>
   <li> <a href="#gcd">Greatest Common Divisors</a> </li>
   <li> <a href="#fibonacci">Fibonacci Sequence</a> 
</li>
   <li><a href="#binarysearch">Binary Search</a> </li>
   <li><a href="#stringpermutation">String Permutations</a> </li>
   <li><a href="#stringcombination">String Combinations</a> </li>
   <li><a href="#subsets">Subsets of a Set</a></li>
</ul>
</div>


<div class="bodytext" style="padding: 12px;" align="justify"> 
<div class="subtitle" id="recursion">Codes - Recursion</div>

<p>Recursion is a deceptively simple concept. Any routine that calls itself is recursive. The concept is quite simple and clear, however, understanding and applying recursion can be amazingly complex.</p>
<p>Recursion is useful for tasks that can be defined in terms of similar subtasks. For instance, sort, search, and traversal problems often have simple recursive solutions. A recursive routine performs a task in part by calling itself to perform the subtasks. However, a recursive program cannot call itself always, or it would never stop. So, at some point, the routine encounters a subtask that it can perform without calling itself. This case is called the <strong>base case</strong>. The other case, in which the routine calls itself to perform a subtask, is called as <strong>recursive case</strong>.</p>
<p>Many interesting algorithms are simply expressed with recursive programs, and many algorithm designers prefer to express methods recursively.</p>
<p>Any problem that can be solved recursively can also be solved iteratively. We often find nonrecursive alternatives that achieve the same final result through a different sequence of computations while the recursive formulation provides a structure within which we can seek more efficient alternatives. <strong>Iterative algorithms</strong> are often quite easy to write, even for tasks that might appear to be fundamentally recursive. Iterative solutions are usually more efficient than recursive solutions.</p>
<br />

<div class="subtitle_2nd" id="printing">Printing a String Reversed</div>
<p>Here we have two print functions, one for normal and the other one for printing a string in reverse.</p>
<pre>
#include &lt;iostream&gt;

using namespace std;

void normalPrint(char *s)
{
	if(*s) {
		putchar(*s);
		normalPrint(s+1);
	}
}
void reversePrint(char *s)
{
	if(*s) {
		reversePrint(s+1);
		putchar(*s);
	}
}

int main() 
{
	char *str = "Normal or Reverse";
	normalPrint(str);
	cout << endl;
	reversePrint(str);
	cout << endl;
	return 0;
}
</pre>
<p>Output is:</p>
<pre>
Normal or Reverse
esreveR ro lamroN
</pre>

<br />

<div class="subtitle_2nd" id="factorial">Factorial</div>
<pre>
#include &lt;iostream&gt;

using namespace std;

int factorial(int n)
{
	if(n == 0 || n == 1) return 1;

	return n * factorial(n-1);
}

int factorial_iter(int n)
{
	int fact = 1;
	for(int i = n; i > 1; i--) {
		fact *= i;
	}
	return fact;
}

int main()
{
	cout << "recursive factorial 10! = " 
			<< factorial(10) << endl;
	cout << "iterative factorial 10! = " 
			<< factorial_iter(10) << endl;
}
</pre>
<p>With output</p>
<pre>
recursive factorial 10! = 3628800
iterative factorial 10! = 3628800
</pre>
<p>We use recursion because it often allows us to express complex algorithms in a compact form, without sacrificing efficiency. As we saw from the example, the recursive implementation of the factorial function obviates the need for <strong>local</strong> variables. The cost of the recursive implementation is borne by the mechanisms in the programming environment that supports function calls, which use the equivalent of a built-in pushdown stack.</p>

<br />
<br />

<div class="subtitle_2nd" id="gcd">Greatest Common Divisors</div>
<p>The following is a compact implementation of <strong>Euclid's algorithm</strong> for finding the <strong>greatest common divisor</strong> of two integers. It is base on the observation that the greatest common divisor of two integers <strong>m</strong> and <strong>n</strong> with <strong>m</strong> > <strong>n</strong>  is the same as the greatest common divisor of <strong>n</strong> and <strong>m mod n</strong>.</p>
<pre>
#include &lt;iostream&gt;
using namespace std;

int gcd (int n1, int n2)
{
	if(n2 == 0) return n1;
	cout << "gcd(" << n1 << ',' << n2 <<')'<< endl; 
	return gcd(n2, n1 % n2);
}

int main()
{
	cout << "gcd = " << gcd(1256636, 1630968) << endl;
	return 0;
}
</pre>
<p>Output from the code is:</p>
<pre>
gcd(1256636,1630968)
gcd(1630968,1256636)
gcd(1256636,374332)
gcd(374332,133640)
gcd(133640,107052)
gcd(107052,26588)
gcd(26588,700)
gcd(700,688)
gcd(688,12)
gcd(12,4)
gcd = 4
</pre>
<br />
<br />
<br />

<div class="subtitle_2nd" id="fibonacci">Fibonacci Sequence</div>
<br />
<pre>
#include &lt;iostream&gt;

using namespace std;

int fibo(int n)
{
	return n <= 1 ? n : fibo(n-1) + fibo(n-2);
}

int fibo_iter(int n)
{
	if(n < 0) return -1;  /* error */
	if(n == 0) return 0;
	if(n == 1) return 1;

	int f1 = 1, f2 = 1, f;
	for(int i = 2; i <= n; i++) {
		f = f1 + f2;
		f1 = f2;
		f2 = f;
	}
	return f;
}

int main()
{
	int i;
	int n = 15;
	cout << "recursive Fibonacci " << endl;
	for(i = 0; i < n; i++) 
		cout <<  fibo(i) << " ";
	cout << endl;

	cout << "iterative Fibonacci " << endl;
	for(i = 0; i < n; i++) 
		cout <<  fibo(i) << " ";
	cout << endl;
}
</pre>
<p>Output is: </p>
<pre>
recursive Fibonacci
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
iterative Fibonacci
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
</pre>
<br />
<br />

<div class="subtitle_2nd" id="binarysearch">Binary Search</div>
<p>This binary search code performs a binary search on a sorted array of integers to find the index of a given integer.</p>
<pre>
#include &lt;iostream&gt;

using namespace std;

const int LIMITS_REVERSED = -1;
const int NOT_IN_ARRAY = -2;
const int UNSORTED_ARRAY = -3;

int binarySearch(int arr[], int lower, int upper, int target)
{
	if(lower > upper)
		return LIMITS_REVERSED;
	else if(lower == upper && arr[lower] != target)
		return NOT_IN_ARRAY;
	
	if(arr[lower] > arr[upper])
		return UNSORTED_ARRAY;

	int center = (upper - lower)/2 + lower;
	if(target == arr[center])
		return center;
	else if(target < arr[center])
		return binarySearch(arr, lower, center - 1, target);
	else
		return binarySearch(arr, center + 1, upper, target);
}

int binarySearch_iter(int arr[], int lower, int upper, int target)
{
	while(true) {
		if(lower > upper)
			return LIMITS_REVERSED;
		else if(lower == upper && arr[lower] != target)
			return NOT_IN_ARRAY;
		if(arr[lower] > arr[upper])
			return UNSORTED_ARRAY;

		int center = (upper - lower)/2 + lower;
		if(target == arr[center])
			return center;
		else if(target < arr[center])
			upper = center - 1;
		else
			lower = center + 1;
	}
}

void message(int error)
{
	if(error == LIMITS_REVERSED)
		cout << "LIMITS_REVERSED\n";
	else if(error == NOT_IN_ARRAY)
		cout << "NOT_IN_ARRAY\n";
	else if(error == UNSORTED_ARRAY)
		cout << "UNSORTED_ARRAY\n";
	else
		return;
}

int main()
{
	/* sorted array */
	int arr[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

	int target = 17;
	int lower = 0;
	int upper = sizeof(arr) / sizeof(int) -1 ;
	int index;

	index = binarySearch(arr, lower, upper, target);
	message(index);
	if(index >= 0) {
		cout << "Recursive: target is =" << target << endl;
		cout << "arr[" << index << "] = " << arr[index] << endl;
	}

	index = binarySearch_iter(arr, lower, upper, target);
	message(index);
	if(index >= 0) {
		cout << "Iterative: target is =" << target << endl;
		cout << "arr[" << index << "] = " << arr[index] << endl;
	}
	return 0;
}
</pre>
<p>Output from the run is:</p>
<pre>
Recursive: target is =17
arr[8] = 17
Iterative: target is =17
arr[8] = 17
</pre>


<br />
<br />
<div class="subtitle_2nd" id="stringpermutation">String Permutations</div>
<p>This code computes all permutations of a string. <br />
If our string is <strong>abs</strong>, the permutations are: <br />
<strong>abc, acb, bac, bca, cab, cbd </strong>.</p>
<pre>
/* String Permutation */

#include &lt;iostream&gt;
using namespace std;

void swap(char* st1, char* st2)
{
	char ch = *st2;
	*st2 = *st1;
	*st1 = ch;
}

int permute(char* str, int start, int end)
{
	if (end - start == 1) {
		cout << str << endl;
	} 
	else {
		for(int i=0; i < end - start; i++) {
			swap(&str[start], &str[start+i]);	
			permute(str, start+1, end);				
			swap(&str[start], &str[start+i]);       
		}
	}
	return 0;
}

int main()
{
	char str[255] = "abc"; 
	permute(str, 0, strlen(str)); 
	return 0;
}
</pre>
<p>Output is </p>
<pre>
abc
acb
bac
bca
cba
cab
</pre>
<br />
<br />

<div class="subtitle_2nd" id="stringcombination">String Combinations</div>
<p>The following code produces all combinations of a given string. In this example, we're using the term <strong>depth of the recursion</strong>. It is the maximum degree of nesting of the function calls over the course of the computation. </p>
<p>Generally, the depth will depend on the input. So, when we write a recursive code, we need to take into account that the programming environment has to maintain a <strong>pushdown stack</strong> of size proportional to the depth of the recursion. Therefore, for a huge problem, we may not be able to resort the recursive approach because of the space needed for stack size.</p>
<p>Data structures build from nodes with pointers are inherently recursive. Linked list, for example, is recursive. So, recursive codes provide natural implementations of many common functions for manipulating such data structures.</p>
<pre>
#include &lt;iostream&gt;
#include &lt;cstring&gt;
using namespace std;

/* depth: the recursion depth 
	    or the index into the output string of the character 
		that's being generated.  */
/* start: the index of the first of the still available letters */

void combinations(char *input, char *output, 
    int len, int depth, int start)
{
    /* At the current depth, 
	   cycle through the still available letters */

    for( int i = start; i < len; i++ ) {
        output[depth] = input[i];
        combinations(input, output, len, depth+1, i+1);
    }
    output[depth] = '\0';
    cout << output << endl;
}

int main() 
{
    char *input = "abcd";
	char *output = new char[strlen(input) + 1];

	combinations(input, output, strlen(input), 0, 0);
	delete [] output;
} 
</pre>
<p>Output from the run is:</p>
<pre>
abcd
abc
abd
ab
acd
ac
ad
a
bcd
bc
bd
b
cd
c
d
</pre>


<br />
<br />

<div class="subtitle_2nd" id="subsets">Subsets of a Set</div>
<p>This code can be summarized as following:</p>
<ul>
	<li>Each element in a set can be in either <strong>yes</strong> or <strong>no</strong> state. This means that each subset is a sequence of <strong>yes/no</strong>, e.g., set with 4 elements, the state can be yes, yes, no, yes.</li>
	<li>This gives us 2<sup>n</sup> possible subsets. <br />
	How can we iterate through all possible sequences of <strong>yes/no</strong> states for all elements?<br />
	If each <strong>no</strong> can be treated as 0 and each <strong>yes</strong> can be treated as a 1, then each subset can be represented as a binary string.</li>
	<li>Generating all subsets then really just comes down to generating all binary numbers.</li> 
</ul>
<pre>
/* subsets of a set - recursive */

#include &lt;iostream&gt;
#include &lt;vector&gt;

using namespace std;

vector<vector<int>> getSubsets(vector<int> &set)
{
	vector<vector<int>> allSubsets;

	int max = 1 << set.size();
	for(int i = 0; i < max; i++) {
		vector<int> subset;
		int j = i;
		int index = 0;
		while (j > 0) {
			if((j & 1) > 0) 
				subset.push_back(set[index]);
			j >>= 1;
			index++;
		}
		allSubsets.push_back(subset);
	}
	return allSubsets;
}

int main() 
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	vector<vector<int>> vv;

	vv = getSubsets(v);
	
	for(int i = 0; i < vv.size(); i++) {
		cout << '(';
		for(int j = 0; j < vv[i].size(); j++) {
			cout << vv[i][j] << ' ';
		}
		cout << ')' << endl;
	}

	return 0;
}
</pre>
<p>Output is:</p>
<pre>
()
(1 )
(2 )
(1 2 )
(3 )
(1 3 )
(2 3 )
(1 2 3 )
(4 )
(1 4 )
(2 4 )
(1 2 4 )
(3 4 )
(1 3 4 )
(2 3 4 )
(1 2 3 4 )
</pre>
<br />
<br />
<p>The recursion is intertwined with the recursively defined structures known as <strong>trees</strong>. So, we can find additional codes related to recursion from the tree structures:</p>
<ul>
   <li><a href="binarytree.html">Binary Tree Example Code</a></li>
</ul>
<br />
<br />

<img src="images/quiz/KahPyoung.png" alt="KahPyoung"/>
<br />
<br />
<br />
<div class="subtitle_2nd" id="FullList">Full List of C++ Tutorials</div>
<ul>
   <li><a href="cpptut.html">C++ Home</a> </li>
   <li><a href="string.html">String</a> </li>
   <li><a href="constructor.html">Constructor</a> </li>
   <li><a href="operatoroverloading.html">Operator Overloading</a></li> 
   <li><a href="virtualfunctions.html">Virtual Functions</a></li>
   <li><a href="dynamic_cast.html">Dynamic Cast Operator</a></li>
   <li><a href="typecast.html">Type Cast Operators</a></li>
   <li><a href="autoptr.html">Class auto_ptr</a></li>
   <li><a href="templates.html">Templates</a></li>
   <li><a href="references.html">References for Built-in Types</a></li>
   <li><a href="valuevsreference.html">Pass by Value vs. Pass by Reference</a></li>
   <li><a href="memoryallocation.html">Memory Allocation</a></li>
   <li><a href="friendclass.html">Friend Functions and Friend Classes</a></li>
   <li><a href="functors.html">Functors (Function Objects)</a></li>
   <li><a href="statics.html">Static Variables and Static Class Members</a></li>
   <li><a href="exceptions.html">Exceptions</a></li>
   <li><a href="pointers.html">Pointers</a></li>
   <li><a href="pointers2.html">Pointers II</a></li>
   <li><a href="pointers3.html">Pointers III</a></li>
   <li><a href="assembly.html">Taste of Assembly</a></li>
   <li><a href="smallprograms.html">Small Programs</a></li>
   <li><a href="linkedlist.html">Linked List Examples</a></li>
   <li><a href="stl.html">Standard Template Library (STL)</a></li>
   <li><a href="stl2.html">Standard Template Library (STL) II - Maps</a></li>
   <li><a href="stl3_iterators.html">Standard Template Library (STL) III - Iterators</a></li>
   <li><a href="slicing.html">Object Slicing and Virtual Table</a></li>
   <li><a href="this_pointer.html">The this Pointer</a></li>
   <li><a href="stackunwinding.html">Stack Unwinding</a></li>
   <li><a href="upcasting_downcasting.html">Upcasting and Downcasting</a></li>
   <li><a href="object_returning.html">Object Returning</a></li>
   <li><a href="private_inheritance.html">Private Inheritance</a></li>
   <li><a href="cplusplus_keywords.html">C++_Keywords</a></li>
   <li><a href="multithreaded.html">Multi-Threaded Programming - Terminology</a></li>
   <li><a href="multithreaded2A.html">Multi-Threaded Programming II - Native Thread for Win32 (A) </a></li>
   <li><a href="multithreaded2B.html">Multi-Threaded Programming II -  Native Thread for Win32 (B) </a></li>
   <li><a href="multithreaded2C.html">Multi-Threaded Programming II -  Native Thread for Win32 (C) </a></li>
   <li><a href="multithreaded2.html">Multi-Threaded Programming II - C++ Thread for Win32</a></li>
   <li><a href="multithreaded3.html">Multi-Threaded Programming III - C++ Class Thread for Pthreads</a></li>
   <li><a href="multithreadedDebugging.html">Multithread Debugging</a></li>
   <li><a href="embeddedSystemsProgramming.html">Embedded Systems Programming</a></li>
   <li><a href="boost.html">Boost</a></li>
   <li>Programming Questions and Solutions
    <ul>
       <li><a href="quiz_strings_arrays.html">Strings and Arrays</a></li>
       <li><a href="quiz_linkedlist.html">Linked List</a></li>
       <li><a href="quiz_recursion.html">Recursion</a></li>
       <li><a href="quiz_bit_manipulation.html">Bit Manipulation</a> </li>
       <li><a href="google_interview_questions.html">140 Google Interview Questions</a> </li>
    </ul>
   </li>

</ul>

<br />
<br />
<div id="rightpanel">
<div align="center">
</div></div>
<br />

<br />
</div>

<br />
<br />
<br />



<div class="smallgraytext" id="footer"><a href="../index.html">Home</a>
| <a href="../about_us.html">About Us</a>
| <a href="../products.html">products</a>
| <a href="../our_services.html">Our Services</a>
| <a href="#">Contact Us</a>
| Bogotobogo &copy; 2011 | <a target="_blank" href="http://www.bogotobogo.com">Bogotobogo </a></div>
</div>
</div>
</body>
</html>

